<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>
<body>
    <script>
        // 函数  天生自带  prototype属性 
        // 每一个对象 都有一个 __proto__ 属性 
        //指向所属构造函数的 prototype 


        // 任何函数的构造函数 是 Function 
        // 任何数组的构造函数 是 Array
        // 任何对象的构造函数 是 Object

        // js 内置构造函数 
        // Function 
        // Object 
        // Array



        // 每个构造函数 都有一个prototype 原型对象  
        // prototype 原型对象 的 constructor 指向构造函数本身 
        // 每个对象有一个 __proto__属性 还行 所属构造函数的prototype 

        // 也就是它指向构造函数的原型对象 





        // 万物皆对象  
        // 每个对象都属于某个类(都属于某个构造函数 )
        // 每个对象都是一个独立的个体  
        // 对象的数据结构  {键:值}


        // typeof []  object 
        // typeof //  object

        // 数组是个对象 
        // 函数是个对象 
        // 对象是个对象 
        // 正则也是个对象  
        // 对象的构造函数 Object 

        // []  Array   Object
        
        function Person(name,age){
            this.name = name;
            this.age = age;
            this.gender = '男';

        }

        Person.prototype.sayHello = function(){
            console.log('hello world')
        }

        var p1 = new Person('zhangsan',18);
        var p2 = new Person('lisi',19);

        // 函数的prototype是个对象数据结构 

        // 对象的访问机制
        // 现在自己身上找 如果有停止 如果没有找自己的__proto__ 它指向所属构造
        // 函数的prototype 如果有 直接使用停止查找  
        // 如果没有 就到自己所属构造函数的prototype的__proto__上查找 
        // 依次类推 如果Object.prototype都没有 那么 返回undefined 

        // 

        // 问题 1  
        // p1的__proto__指向谁 ?
        // p1所属的构造函数是Person 
        // p1的__proto__ 就是 Person的prototype

        // 问题 2
        // Person的__proto__指向谁?
        // Person是个函数 任何函数的 构造函数都是Function

        // Person的__proto__ === Function 的prototype 
        // 问题3 
        // Person的prototype的__proto__ 指向谁?

        //Person的prototype是个对象结构  
        // 任何对象的构造函数都是Object
            
        // Person.prototype.__proto__ ===   Object.prototype

        // 问题4
        // Function的__proto__指向谁?
        // Function 内置构造函数 任何函数的构造函数 是Function
        // Function.__proto__    ===    Function.prototype
        // 问题5 
        // Function的prototype的 __proto__指向谁?
        //Function的prototype 是个对象数据结构 
        // 任何对象的构造函数是Object 
        // prototype是对象数据结构  任何对象的构造函数是Object
        // Function.prototype.__proto__ ===   Object.prototype

        // 问题6 
        // Object的__proto__指向谁? 
        // Object 也是内置构造函数 
        // 任何函数的 构造函数 是Function
        // 对象的proto 指向所属构造函数的prototype 
        // Object.__proto__      Function.prototype

        //问题7 
        // Object.prototype的__proto__指向谁?

        // Object.prototype 一定是个对象结构  
        //Object.prototype.__proto__    
        // 一切都是对象  所以Object.prototype  是顶级原型 
        // Object.prototype.__proto__   结果是null 


        // 问题1 
        //p1的__proto__指向谁 ?
        // console.log(p1.__proto__); //返回的是一个对象结构 所属构造函数的原型 
        // console.log(p1.__proto__ === Person.prototype); //返回的是一个对象结构 所属构造函数的原型 

        // 问题2 Person的__proto__
        // console.log(Person.__proto__ === Function.prototype);
        

        // 问题3:
        // console.log(Person.prototype.__proto__ ===   Object.prototype)
    
        // 问题4: 

        // console.log( Function.__proto__  ===     Function.prototype)

        // 问题5 
        // console.log(Function.prototype.__proto__ ===   Object.prototype)
    
        // 问题6

        //   console.log(Object.__proto__  === Function.prototype);
    
        // 问题7

        // console.log(Object.prototype.__proto__);
        // Object.prototype 没有构造函数了  
        // 结果是null
    </script>
</body>
</html>